home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / com / bbs / protocol / zmdm / sz.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-26  |  28.1 KB  |  1,401 lines
  1. /*
  2.  *                ACKNOWLEDGEMENTS
  3.  *
  4.  *    ZMDM was derived from rz/sz for Unix  posted by 
  5.  *    Chuck Forsberg (...!tektronix!reed!omen!caf ). We
  6.  *    thank him for his excellent code, and for giving
  7.  *    us permission to use and distribute his code and
  8.  *    documentation.
  9.  *
  10.  *    Atari St version by:
  11.  *        Jwahar Bammi
  12.  *            usenet: cwruecmp!bammi@decvax.UUCP
  13.  *            csnet:  bammi@cwru.edu
  14.  *            arpa:   bammi@cwru.edu
  15.  *            CompuServe: 71515,155
  16.  */
  17.  
  18. #define SVERSION "sz 1.23 01-15-87"
  19. #define SSTVERSION "sz 1.01 03-07-87"
  20. #define OS    "Unix V7/BSD"
  21.  
  22. /* #define SDEBUG */
  23.  
  24. /*% cc -O -K -DCRCTABLE -DREADCHECK sz.c -lx -o sz; size sz
  25.  
  26.  * sz.c By Chuck Forsberg
  27.  *
  28.  *    cc -O sz.c -o sz        USG (SYS III/V) Unix
  29.  *     cc -O -DV7  sz.c -o sz        Unix Version 7, 2.8 - 4.3 BSD
  30.  *
  31.  *        define CRCTABLE to use table driven CRC
  32.  *
  33.  *  ******* Some systems (Venix, Coherent, Regulus) do not *******
  34.  *  ******* support tty raw mode read(2) identically to    *******
  35.  *  ******* Unix. ONEREAD must be defined to force one     *******
  36.  *  ******* character reads for these systems.           *******
  37.  *
  38.  * A program for Unix to send files and commands to computers running
  39.  *  Professional-YAM, PowerCom, YAM, IMP, or programs supporting Y/XMODEM.
  40.  *
  41.  *  Sz uses buffered I/O to greatly reduce CPU time compared to UMODEM.
  42.  *
  43.  *  USG UNIX (3.0) ioctl conventions courtesy Jeff Martin
  44.  *
  45.  *    St v 1.01
  46.  *        added support for 32 bit CRC's (Zmodem) ++jrb
  47.  *
  48.  */
  49.  
  50. #include "zmdm.h"
  51. #include "common.h"
  52. #include "zmodem.h"
  53.  
  54. #define SLOGFILE "szlog"
  55.  
  56. #define purgeline()    while(Bconstat(1)) Bconin(1)
  57. #define S_IFDIR 0x0010
  58.  
  59. /*
  60.  * Attention string to be executed by receiver to interrupt streaming data
  61.  *  when an error is detected.  A pause (0336) may be needed before the
  62.  *  ^C (03) or after it.
  63.  */
  64. #ifdef READCHECK
  65. char Myattn[] = { 0 };
  66. #else
  67. #ifdef USG
  68. char Myattn[] = { 03, 0336, 0 };
  69. #else
  70. char Myattn[] = { 0 };
  71. #endif
  72. #endif
  73.  
  74. #ifdef MWC
  75. FILE *fopen();
  76. #else
  77. FILE *fopen(), *fopenb();
  78. #endif
  79. static unsigned long SaveIntr;
  80. static int Resuming;
  81. static int in;
  82.  
  83. /* called by signal interrupt or terminate to clean things up */
  84. bibis(n)
  85. int n;
  86. {
  87.     canit(); flush_modem(); mode(0);
  88.     fprintf(stderr, "\r\nsz: caught signal %d; exiting\n", n);
  89.  
  90.     aexit(128+n);
  91. }
  92.  
  93. /* Called when Zmodem gets an interrupt (^X) */
  94. #ifdef ONINTR
  95. onintr()
  96. {
  97.     siggi = 0;
  98.     longjmp(intrjmp, -1);
  99. }
  100. #endif
  101.  
  102. #define ZKER
  103. int Zctlesc;    /* Encode control characters */
  104.  
  105.  
  106. int dosz(argc, argv)
  107. int argc;
  108. char **argv;
  109. {
  110.     register char *cp;
  111.     register int npats;
  112.     int agcnt; char **agcv;
  113.     char **patts;
  114.  
  115.     
  116.     SendType = 1;
  117.     Rxtimeout = 600;
  118.     npats=0;
  119.     if (argc<2)
  120.     {
  121.         susage();
  122.         return(1);
  123.     }
  124.  
  125.     initz();
  126.     schkinvok(argv[0]);
  127.     SaveIntr = Setexc(0x0102, -1L);
  128.     BusErr   = Setexc(2, -1L);
  129.     AddrErr  = Setexc(3, -1L);
  130.  
  131.     Verbose = 0;
  132.     Resuming = FALSE;
  133.     in = (-1);
  134.     vdebug = 0;
  135.  
  136. #ifdef SDEBUG
  137.     logf = (FILE *)NULL;
  138. #endif
  139.     while (--argc) {
  140.         cp = *++argv;
  141.         if (*cp++ == '-' && *cp) {
  142.             while ( *cp) {
  143.                 switch(*cp++) {
  144.                 case '+':
  145.                     Lzmanag = ZMAPND; break;
  146. #ifdef CSTOPB
  147.                 case '2':
  148.                     Twostop = TRUE; break;
  149. #endif
  150.                 case '7':
  151.                     Wcsmask=0177; break;
  152.  
  153. /*
  154.     On the St we look up the ext and decide. For Xmodem
  155.     transfers, the file is always sent in binary mode
  156.     and it is the responsibility of the receiver to
  157.     strip CR if so desired.
  158.                 case 'a':
  159.                     Lzconv = ZCNL;
  160.                     Ascii = TRUE; break;
  161.                 case 'b':
  162.                     Lzconv = ZCBIN; break;
  163. */
  164.                 case 'C':
  165.                     if (--argc < 1) {
  166.                         susage();
  167.                         return(1);
  168.                     }
  169.                     Cmdtries = atoi(*++argv);
  170.                     break;
  171.                 case 'i':
  172.                     Cmdack1 = ZCACK1;
  173.                     /* **** FALL THROUGH TO **** */
  174.                 case 'c':
  175.                     if (--argc != 1) {
  176.                         susage();
  177.                         return(1);
  178.                     }
  179.                     Command = TRUE;
  180.                     Cmdstr = *++argv;
  181.                     break;
  182.                 case 'd':
  183.                     ++Dottoslash;
  184.                     /* **** FALL THROUGH TO **** */
  185.                 case 'f':
  186.                     Fullname=TRUE; break;
  187.                 case 'E':
  188.                     Zctlesc = (-1); break;
  189.                 case 'e':
  190.                     Zctlesc = 1; break;
  191.                 case 'k':
  192.                     Blklen=KSIZE; break;
  193.                 case 'L':
  194.                     if (--argc < 1) {
  195.                         susage();
  196.                         return(1);
  197.                     }
  198.                     blkopt = atoi(*++argv);
  199.                     if (blkopt<32 || blkopt>1024)
  200.                     {
  201.                         susage();
  202.                         return(1);
  203.                     }
  204.                     break;
  205.                 case 'l':
  206.                     if (--argc < 1) {
  207.                         susage();
  208.                         return(1);
  209.                     }
  210.                     Tframlen = atoi(*++argv);
  211.                     if (Tframlen<32 || Tframlen>1024)
  212.                     {
  213.                         susage();
  214.                         return(1);
  215.                     }
  216.                     break;
  217.                 case 'N':
  218.                     Lzmanag = ZMDIFF;  break;
  219.                 case 'n':
  220.                     Lzmanag = ZMNEW;  break;
  221.                 case 'o':
  222.                     Wantfcs32 = FALSE; break;
  223.                 case 'p':
  224.                     Lzmanag = ZMPROT;  break;
  225.                 case 'r':
  226.                     Lzconv = ZCRESUM; Resuming = TRUE; break;
  227.                 case 'q':
  228.                     Quiet=TRUE; Verbose=0; break;
  229.                 case 't':
  230.                     if (--argc < 1) {
  231.                         susage();
  232.                         return(1);
  233.                     }
  234.                     Rxtimeout = atoi(*++argv);
  235.                     if (Rxtimeout<10 || Rxtimeout>1000)
  236.                     {
  237.                         susage();
  238.                         return(1);
  239.                     }
  240.                     break;
  241. #ifdef TESTATTN
  242.                 case 'T':
  243.                     Testattn = TRUE; break;
  244. #endif
  245.                 case 'u':
  246.                     ++Unlinkafter; break;
  247.                 case 'v':
  248.                     ++Verbose; break;
  249.                 case 'X':
  250.                     ++Modem; break;
  251.                 case 'y':
  252.                     Lzmanag = ZMCLOB; break;
  253.                 default:
  254.                     susage();
  255.                     return(1);
  256.                 }
  257.             }
  258.         }
  259.         else if ( !npats && argc>0) {
  260.             if (argv[0][0]) {
  261.                 npats=argc;
  262.                 patts=argv;
  263.             }
  264.         }
  265.     }
  266.     if (npats < 1 && !Command) 
  267.     {
  268.         susage();
  269.         return(1);
  270.     }
  271.  
  272. #ifdef SDEBUG
  273.     if (Verbose > 2)
  274.     {
  275.         if ((logf = fopen(SLOGFILE, "a"))== (FILE *)NULL)
  276.         {
  277.             fprintf(stderr, "Can't open log file %s\n",SLOGFILE);
  278.             return(0200);
  279.         }
  280.         fprintf(logf, "Progname=%s\n", Progname);
  281.         vdebug = 1;
  282.         fflush(logf);
  283.     }
  284. #endif
  285.  
  286.     if ( !Quiet)
  287.     {
  288.         if (Verbose < 2)
  289.             Verbose = 2;
  290.     }
  291.  
  292.  
  293.     Setexc(0x0102, bibis);
  294.     Setexc(2, buserr);
  295.     Setexc(3, addrerr);
  296.  
  297.     if(setjmp(busjmp))
  298.     {
  299.         /* On a bus error - instead of 2 bombs */
  300.         fprintf(stderr,"\r\nFATAL: Bus Error\n\n");
  301. #ifdef SDEBUG
  302.         if(logf != (FILE *)NULL)
  303.             fclose(logf);
  304. #endif
  305.         if(in != -1)
  306.         {
  307.             stfclose(in);
  308.             in = (-1);
  309.         }
  310.         canit();
  311.         Setexc(2, BusErr);
  312.         Setexc(3, AddrErr);
  313.         Setexc(0x0102, SaveIntr);
  314.         return(2);
  315.     }
  316.  
  317.     if(setjmp(addrjmp))
  318.     {
  319.         /* On address error - instead of 3 bombs */
  320.         fprintf(stderr,"\r\nFATAL: Address Error\n\n");
  321. #ifdef SDEBUG
  322.         if(logf != (FILE *)NULL)
  323.             fclose(logf);
  324. #endif
  325.         if(in != -1)
  326.         {
  327.             stfclose(in);
  328.             in = (-1);
  329.         }
  330.         canit();
  331.         Setexc(2, BusErr);
  332.         Setexc(3, AddrErr);
  333.         Setexc(0x0102, SaveIntr);
  334.         return(3);
  335.     }
  336.  
  337.     if((Exitcode = setjmp(abrtjmp)))
  338.     {
  339.         fprintf(stderr,"\nTransfer ABORT\n\n");
  340. #ifdef SDEBUG
  341.     if(logf != (FILE *)NULL)
  342.         fclose(logf);
  343. #endif
  344.         if(in != -1)
  345.         {
  346.             stfclose(in);
  347.             in = (-1);
  348.         }
  349.         Setexc(2, BusErr);
  350.         Setexc(3, AddrErr);
  351.         Setexc(0x0102, SaveIntr);
  352.         return(Exitcode);
  353.     }
  354.  
  355.     mode(1);
  356.  
  357.  
  358.     if ( !Modem) {
  359.         if (!Command && !Quiet && Verbose != 1)
  360.         {
  361.             fprintf(stderr, "sz: %d file%s requested:\n",
  362.                 npats, npats>1?"s":"");
  363.             for ( agcnt=npats, agcv=patts; --agcnt>=0; )
  364.             {
  365.                 fprintf(stderr, "%s ", *agcv++);
  366.             }
  367.             fprintf(stderr, "\n\n");
  368.  
  369. #ifdef SDEBUG
  370.             if(Verbose > 2)
  371.             {
  372.                 fprintf(logf, "sz: %d file%s requested:\n",
  373.                     npats, npats>1?"s":"");
  374.                 for ( agcnt=npats, agcv=patts; --agcnt>=0; )
  375.                 {
  376.                     fprintf(logf, "%s ", *agcv++);
  377.                 }
  378.                 fprintf(logf, "\n");
  379.                 fflush(logf);
  380.             }
  381. #endif
  382.         }
  383.         if (!Nozmodem) {
  384.             stohdr(0L);
  385.             if (Command)
  386.                 Txhdr[ZF0] = ZCOMMAND;
  387.             zshhdr(ZRQINIT, Txhdr);
  388.         }
  389.     }
  390.     flush_modem();
  391.  
  392.     if (Command) {
  393.         if (getzrxinit()) {
  394.             Exitcode=0200; canit();
  395.         }
  396.         else if (zsendcmd(Cmdstr, 1+strlen(Cmdstr))) {
  397.             Exitcode=0200; canit();
  398.         }
  399.     } else if (wcsend(npats, patts)==ERROR) {
  400.         Exitcode=0200;
  401.         canit();
  402.     }
  403.     flush_modem();
  404.     mode(0);
  405.  
  406. #ifdef SDEBUG
  407.     if(logf != (FILE *)NULL)
  408.         fclose(logf);
  409. #endif
  410.     if(in != -1)
  411.     {
  412.         fclose(in);
  413.         in = (-1);
  414.     }
  415.  
  416.     putc('\n', stderr);
  417.     Setexc(2, BusErr);
  418.     Setexc(3, AddrErr);
  419.     Setexc(0x0102, SaveIntr);
  420.     return((errcnt != 0) | Exitcode);
  421.     /*NOTREACHED*/
  422. }
  423.  
  424. wcsend(argc, argp)
  425. char *argp[];
  426. {
  427.     register int n;
  428.  
  429.     Crcflg=FALSE;
  430.     Firstsec=TRUE;
  431.     for (n=0; n<argc; ++n) {
  432.         Totsecs = 0;
  433.         if (wcs(argp[n])==ERROR)
  434.             return ERROR;
  435.     }
  436.     Totsecs = 0;
  437.     if (Filcnt==0) {    /* bitch if we couldn't open ANY files */
  438.         if (1) {
  439.             Command = TRUE;
  440.             Cmdstr = "echo \"sz: Can't open any requested files\"";
  441.             if (getzrxinit()) {
  442.                 Exitcode=0200; canit();
  443.             }
  444.             else if (zsendcmd(Cmdstr, 1+strlen(Cmdstr))) {
  445.                 Exitcode=0200; canit();
  446.             }
  447.             Exitcode = 1; return OK;
  448.         }
  449.         canit();
  450.         fprintf(stderr,"\n\nCan't open any requested files.\n\n");
  451.         return ERROR;
  452.     }
  453.     if (Zmodem)
  454.         saybibi();
  455.     else
  456.         wctxpn("");
  457.     return OK;
  458. }
  459.  
  460. wcs(oname)
  461. char *oname;
  462. {
  463.     extern struct stat statbuf;
  464.     char name[PATHLEN];
  465.  
  466.     strcpy(name, oname);
  467.     ++Noeofseen;  Lastread = 0;  Lastc = (-1); Dontread = FALSE;
  468.  
  469.     /* Check for directory or block special files */
  470.     if(Fsfirst(name,(int)(0x01 | 0x010 | 0x020)) != 0)
  471.     {
  472.         ++errcnt;
  473.         return OK;    /* may be others */
  474.     }
  475.  
  476.     if (statbuf.st_mode & S_IFDIR ) {
  477.         return OK;
  478.     }
  479.  
  480.     if((in = stfopen(oname,"r")) <= 0){
  481.         ++errcnt;
  482.         return OK;    /* pass over it, there may be others */
  483.     }
  484.  
  485.     ++Filcnt;
  486.     switch (wctxpn(name)) {
  487.     case ERROR:
  488.         return ERROR;
  489.     case ZSKIP:
  490.         return OK;
  491.     }
  492.     if (!Zmodem && wctx()==ERROR)
  493.         return ERROR;
  494.     if (Unlinkafter)
  495.         unlink(oname);
  496.     return 0;
  497. }
  498.  
  499. #define ISDRIVE(X) ( (((X >= 'a') && (X <= 'n'))) || ((X >= 'A') && (X <= 'N')))
  500. /*
  501.  * generate and transmit pathname block consisting of
  502.  *  pathname (null terminated),
  503.  *  file length, mode time and file mode in octal
  504.  *  as provided by the St's Fsfirst() call.
  505.  *  N.B.: modifies the passed name, may extend it!
  506.  */
  507. wctxpn(name)
  508. char *name;
  509. {
  510.     register char *p, *q;
  511.     char name2[PATHLEN];
  512.     unsigned long unixtime;
  513.     extern struct stat statbuf;
  514.     extern unsigned long st2unix();    /* Convert St's date and time to unix
  515.                    time (seconds since Jan 1 1970 00:00:00) */
  516.  
  517.     if(*name)
  518.         if(Fsfirst(name,(int)(0x01 | 0x020)) != 0)
  519.             return ERROR;
  520.  
  521.     if (Modem) {
  522.         if (*name) {
  523.             fprintf(stderr, "Outgoing:\n\t Name: %s\n\t Size: %ld Bytes\n\tBlocks: %ld\n\n",
  524.               name, statbuf.st_size, statbuf.st_size>>7);
  525.         }
  526.         return OK;
  527.     }
  528.  
  529.     vfile2("\r\nAwaiting pathname nak for %s\r\n", *name?name:"<END>");
  530.  
  531.     if ( !Zmodem)
  532.         if (getnak())
  533.             return ERROR;
  534.  
  535.     /* convert to Unix style path names */
  536.     /* skip any device identifier */
  537.     if(ISDRIVE(name[0]) && (name[1] == ':'))
  538.         name = &name[2];
  539.  
  540.     for(p = name; *p != '\0'; p++)
  541.     {
  542.         if(*p == '\\')
  543.             *p = '/';
  544.     }
  545.  
  546.     if(!Resuming)
  547.     {
  548.         if(!isbinary(name))
  549.         {
  550.             /* We indicate to the other side */
  551.             Lzconv = ZCNL;
  552.             Ascii = TRUE;
  553.         }
  554.         else
  555.         {
  556.             Lzconv = ZCBIN;
  557.             Ascii = FALSE;
  558.         }
  559.     }
  560.  
  561.     q = (char *) 0;
  562.     if (Dottoslash) {        /* change . to . */
  563.         for (p=name; *p; ++p) {
  564.             if (*p == '/')
  565.                 q = p;
  566.             else if (*p == '.')
  567.                 *(q=p) = '/';
  568.         }
  569.         if (q && strlen(++q) > 8) {    /* If name>8 chars */
  570.             q += 8;            /*   make it .ext */
  571.             strcpy(name2, q);    /* save excess of name */
  572.             *q = '.';
  573.             strcpy(++q, name2);    /* add it back */
  574.         }
  575.     }
  576.  
  577.     for (p=name, q=secbuf ; *p; )
  578.         if ((*q++ = *p++) == '/' && !Fullname)
  579.             q = secbuf;
  580.     *q++ = 0;
  581.     p=q;
  582.     while (q < (secbuf + KSIZE))
  583.         *q++ = 0;
  584.     if (*name)
  585.     {
  586.         unixtime = st2unix(statbuf.st_time, statbuf.st_date);
  587.         sprintf(p, "%lu %lo %o", statbuf.st_size,
  588.             unixtime,
  589.              ((statbuf.st_mode & 0x01)?0444:0644));
  590.     }
  591.  
  592.     if(Verbose)
  593.         fprintf(stderr,
  594.         "Outgoing: [Hit CTRL-C to Cancel]\n\tName: %s\n\tSize: %ld Bytes\n",
  595.             name, statbuf.st_size);
  596.     if(!Resuming)
  597.     {
  598.         fprintf(stderr,"\tMode: %s\n\n", (Ascii)?"ASCII":"BINARY");
  599.     }
  600.     else
  601.     {
  602.         fprintf(stderr,"\tMode: Resume Transfer Mode\n\n");
  603.     }
  604.  
  605. #ifdef SDEBUG
  606.     if(Verbose > 2)
  607.     {
  608.         fprintf(stderr,"File: %s (%s)\n", name, p);
  609.         fprintf(logf,"File: %s (%s)\n", name, p);
  610.         fflush(logf);
  611.     }
  612. #endif
  613.  
  614.     /* force 1k blocks if name won't fit in 128 byte block */
  615.     if (secbuf[125])
  616.         Blklen=KSIZE;
  617.     else {        /* A little goodie for IMP/KMD */
  618.         if (Zmodem)
  619.             Blklen = SECSIZ;
  620.         secbuf[127] = (statbuf.st_size + 127) >>7;
  621.         secbuf[126] = (statbuf.st_size + 127) >>15;
  622.     }
  623.     if (Zmodem)
  624.         return zsendfile(secbuf, (int)(1+strlen(p)+ 
  625.                 (int)((long)p-(long)secbuf)));
  626.     if (wcputsec(secbuf, 0, SECSIZ)==ERROR)
  627.         return ERROR;
  628.     return OK;
  629. }
  630.  
  631. getnak()
  632. {
  633.     register int firstch;
  634.  
  635.     Lastrx = 0;
  636.     for (;;) {
  637.         switch (firstch = readock(800,1)) {
  638.         case ZPAD:
  639.             if (getzrxinit())
  640.                 return ERROR;
  641.             Ascii = 0;
  642.             return FALSE;
  643.         case TIMEOUT:
  644.             vfile("Timeout on pathname\n");
  645.             return TRUE;
  646.         case WANTG:
  647. #ifdef USG
  648.             mode(2);    /* Set cbreak, XON/XOFF, etc. */
  649. #endif
  650.             Optiong = TRUE;
  651.             Blklen=KSIZE;
  652.         case WANTCRC:
  653.             Crcflg = TRUE;
  654.         case NAK:
  655.             return FALSE;
  656.         case CAN:
  657.             if ((firstch = readock(20,1)) == CAN && Lastrx == CAN)
  658.                 return TRUE;
  659.         default:
  660.             break;
  661.         }
  662.         Lastrx = firstch;
  663.     }
  664. }
  665.  
  666.  
  667. wctx()
  668. {
  669.     register int sectnum, attempts, firstch;
  670.  
  671.     Firstsec=TRUE;
  672.  
  673.     while ((firstch=readock(Rxtimeout, 2))!=NAK && firstch != WANTCRC
  674.       && firstch != WANTG && firstch!=TIMEOUT && firstch!=CAN)
  675.         ;
  676.     if (firstch==CAN) {
  677.         fprintf(stderr, "\r\nReceiver CANcelled\n");
  678.         return ERROR;
  679.     }
  680.     if (firstch==WANTCRC)
  681.         Crcflg=TRUE;
  682.     if (firstch==WANTG)
  683.         Crcflg=TRUE;
  684.     sectnum=1;
  685.     while (filbuf(secbuf, Blklen)) {
  686.         if (wcputsec(secbuf, sectnum, Blklen)==ERROR) {
  687.             return ERROR;
  688.         } else
  689.             sectnum++;
  690.     }
  691.  
  692.     if (Verbose>1)
  693.     {
  694.         fprintf(stderr, "\nClosing\n\n");
  695. #ifdef SDEBUG
  696.         if(Verbose > 2)
  697.         {
  698.             fprintf(logf, " Closing\n");
  699.             fflush(logf);
  700.         }
  701. #endif
  702.     }
  703.  
  704.     stfclose(in);
  705.     in = (-1);
  706.  
  707.     attempts=0;
  708.     do {
  709.         vfile(" EOT ");
  710.         purgeline();
  711.         sendline(EOT);
  712.         flush_modem();
  713.         ++attempts;
  714.     }
  715.         while ((firstch=(readock(Rxtimeout, 1)) != ACK) && attempts < RETRYMAX);
  716.     if (attempts == RETRYMAX) {
  717.         fprintf(stderr, "\r\nNo ACK on EOT\n");
  718.         return ERROR;
  719.     }
  720.     else
  721.         return OK;
  722. }
  723.  
  724. wcputsec(buf, sectnum, cseclen)
  725. char *buf;
  726. int sectnum;
  727. int cseclen;    /* data length of this sector to send */
  728. {
  729.     register int checksum, wcj;
  730.     register char *cp;
  731.     unsigned int oldcrc;
  732.     int firstch;
  733.     int attempts;
  734.  
  735.     firstch=0;    /* part of logic to detect CAN CAN */
  736.  
  737.     if (Verbose>1)
  738.     {
  739.         fprintf(stderr, "\rBlock %06d  %04dK ", Totsecs, (Totsecs>>3));
  740. #ifdef SDEBUG
  741.         if(Verbose > 2)
  742.         {
  743.             fprintf(logf, "\rBlock %d %dK ", Totsecs, (Totsecs>>3) );
  744.             fflush(logf);
  745.         }
  746. #endif
  747.     }
  748.  
  749.     for (attempts=0; attempts <= RETRYMAX; attempts++) {
  750.         Lastrx= firstch;
  751.         sendline(cseclen==KSIZE?STX:SOH);
  752.         sendline(sectnum);
  753.         sendline(-sectnum -1);
  754.         oldcrc=checksum=0;
  755.         for (wcj=cseclen,cp=buf; --wcj>=0; ) {
  756.             sendline(*cp);
  757.             oldcrc=updcrc((0377& *cp), oldcrc);
  758.             checksum += *cp++;
  759.         }
  760.         if (Crcflg) {
  761.             oldcrc=updcrc(0,updcrc(0,oldcrc));
  762.             sendline((int)oldcrc>>8);
  763.             sendline((int)oldcrc);
  764.         }
  765.         else
  766.             sendline(checksum);
  767.  
  768.         if (Optiong) {
  769.             Firstsec = FALSE; return OK;
  770.         }
  771.         firstch = readock(Rxtimeout, (Noeofseen&§num) ? 2:1);
  772. gotnak:
  773.         switch (firstch) {
  774.         case CAN:
  775.             if(Lastrx == CAN) {
  776. cancan:
  777.                 fprintf(stderr, "\r\nCancelled\n");  return ERROR;
  778.             }
  779.             break;
  780.         case TIMEOUT:
  781.             vfile("Timeout on sector ACK\n"); continue;
  782.         case WANTCRC:
  783.             if (Firstsec)
  784.                 Crcflg = TRUE;
  785.         case NAK:
  786.             vfile("NAK on sector\n"); continue;
  787.         case ACK: 
  788.             Firstsec=FALSE;
  789.             Totsecs += (cseclen>>7);
  790.             return OK;
  791.         case ERROR:
  792.             vfile("Got burst for sector ACK\n"); break;
  793.         default:
  794.             vfile("Got %02x for sector ACK\n", firstch); break;
  795.         }
  796.         for (;;) {
  797.             Lastrx = firstch;
  798.             if ((firstch = readock(Rxtimeout, 2)) == TIMEOUT)
  799.                 break;
  800.             if (firstch == NAK || firstch == WANTCRC)
  801.                 goto gotnak;
  802.             if (firstch == CAN && Lastrx == CAN)
  803.                 goto cancan;
  804.         }
  805.     }
  806.     fprintf(stderr, "\r\nRetry Count Exceeded\n");
  807.     return ERROR;
  808. }
  809.  
  810. /* fill buf with count chars padding with ^Z for CPM */
  811. filbuf(buf, count)
  812. register unsigned char *buf;
  813. register int count;
  814. {
  815.     register int m;
  816.  
  817.     if((buf[0] = stgetc(in)) == EOF)
  818.         return 0;
  819.  
  820.     for(m = 1; (m < count) && ((buf[m] = stgetc(in)) != EOF); m++)
  821.         /* loop */ ;
  822.  
  823.     while (m < count)
  824.         buf[m++] = 032;
  825.  
  826.     return count;
  827.  
  828. }
  829. /* fill buf with count chars */
  830. zfilbuf(buf, count)
  831. register char *buf;
  832. {
  833.     register int c, m;
  834.  
  835.     m=count;
  836.     while ((c=stgetc(in))!=EOF) {
  837.         *buf++ =c;
  838.         if (--m == 0)
  839.             break;
  840.     }
  841.     return (count - m);
  842. }
  843.  
  844. /*
  845.  * readock(timeout, count) reads character(s) from file descriptor 0
  846.  *  (1 <= count <= 3)
  847.  * it attempts to read count characters. If it gets more than one,
  848.  * it is an error unless all are CAN
  849.  * (otherwise, only normal response is ACK, CAN, or C)
  850.  *  Only looks for one if Optiong, which signifies cbreak, not raw input
  851.  *
  852.  * timeout is in tenths of seconds
  853.  */
  854. readock(timeout, count)
  855. int timeout, count;
  856. {
  857.     register int c;
  858.     static char byt[5];
  859.  
  860.     if (Optiong)
  861.         count = 1;    /* Special hack for cbreak */
  862.  
  863.     if (setjmp(tohere)) {
  864.         vfile("TIMEOUT\n");
  865.         return TIMEOUT;
  866.     }
  867.     c = timeout >> 3;
  868.     if (c<2)
  869.         c=2;
  870. #ifdef SDEBUG
  871.     if (Verbose>3) {
  872.         fprintf(stderr, "Timeout=%d Calling alarm(%d) ", timeout, c);
  873.         byt[1] = 0;
  874.         fprintf(logf, "Timeout=%d Calling alarm(%d) ", timeout, c);
  875.         fflush(logf);
  876.  
  877.     }
  878. #endif
  879.     stalarm(c);
  880.     c=read_modem(byt, count);
  881.  
  882.     stalarm(0);
  883. #ifdef SDEBUG
  884.     if (Verbose>5)
  885.     {
  886.         fprintf(stderr, "ret cnt=%d %x %x\n", c, byt[0], byt[1]);
  887.         fprintf(logf, "ret cnt=%d %x %x\n", c, byt[0], byt[1]);
  888.         fflush(logf);
  889.     }
  890. #endif
  891.  
  892.     if (c<1)
  893.         return TIMEOUT;
  894.     if (c==1)
  895.         return (byt[0]&0377);
  896.     else
  897.         while (c)
  898.             if (byt[--c] != CAN)
  899.                 return ERROR;
  900.     return CAN;
  901. }
  902.  
  903. sreadline(n)
  904. {
  905.     return (readock(n, 1));
  906. }
  907.  
  908.  
  909. susage()
  910. {
  911.     fprintf(stderr,"\nSend file(s) with ZMODEM/YMODEM/XMODEM Protocol\n");
  912.     fprintf(stderr,"    (Y) = Option applies to YMODEM only\n");
  913.     fprintf(stderr,"    (Z) = Option applies to ZMODEM only\n");
  914.     fprintf(stderr,
  915.     "%s for %s by ST Enthusiasts at Case Western Reserve University\n",
  916.        SSTVERSION, STOS);
  917.     fprintf(stderr,"\tBased on %s for %s by Chuck Forsberg\n\n", SVERSION, OS);
  918. /*    fprintf(stderr,"Usage:    sz [-12+adefknquvXy] [-] file ...\n"); */
  919.     fprintf(stderr,"Usage:    sz [-+defknquvXy] file ...\n");
  920. /*    fprintf(stderr,"    sz [-1eqv] -c COMMAND\n"); */
  921.     fprintf(stderr,"    sz [-eqv] -c COMMAND\n");
  922. /*    fprintf(stderr,"    1 Use stdout for modem input\n"); */
  923. #ifdef CSTOPB
  924.     fprintf(stderr,"    2 Use 2 stop bits\n");
  925. #endif
  926.     fprintf(stderr,"    + Append to existing destination file (Z)\n");
  927. /*    fprintf(stderr,"    a (ASCII) change NL to CR/LF\n"); */
  928.     fprintf(stderr,"    c send COMMAND (Z)\n");
  929.     fprintf(stderr,"    d Change '.' to '/' in pathnames (Y/Z)\n");
  930.     fprintf(stderr,"    e Escape control characters (Z)\n");
  931.     fprintf(stderr,"    f send Full pathname (Y/Z)\n");
  932.     fprintf(stderr,"    i send COMMAND, ack Immediately (Z)\n");
  933.     fprintf(stderr,"    k Send 1024 byte packets (Y)\n");
  934.     fprintf(stderr,"    L N Limit packet length to N bytes (Z)\n");
  935.     fprintf(stderr,"    l N Limit frame length to N bytes (l>=L) (Z)\n");
  936.     fprintf(stderr,"    n send file if Newer|longer (Z)\n");
  937.     fprintf(stderr,"    N send file if different length|date (Z)\n");
  938.     fprintf(stderr, "    o Use 16 bit CRC instead of 32 bit CRC (Z)\n");
  939.     fprintf(stderr,"    p Protect existing destination file (Z)\n");
  940.     fprintf(stderr,"    r Resume/Recover interrupted file transfer (Z)\n");
  941.     fprintf(stderr,"    q Quiet (no progress reports)\n");
  942.     fprintf(stderr,"    u Unlink file after transmission\n");
  943.     fprintf(stderr,"    v Verbose - debugging information\n");
  944.     fprintf(stderr,"    X XMODEM protocol - send no pathnames\n");
  945.     fprintf(stderr,"    y Yes, overwrite existing file (Z)\n");
  946. /*    fprintf(stderr,
  947. "- as pathname sends standard input as sPID.sz or environment ONAME\n"); */
  948.     return(1);
  949. }
  950.  
  951. /*
  952.  * Get the receiver's init parameters
  953.  */
  954. getzrxinit()
  955. {
  956.     register int n;
  957.  
  958.     for (n=10; --n>=0; ) {
  959.         
  960.         switch (zgethdr(Rxhdr, 1)) {
  961.         case ZCHALLENGE:    /* Echo receiver's challenge numbr */
  962.             stohdr(Rxpos);
  963.             zshhdr(ZACK, Txhdr);
  964.             continue;
  965.         case ZCOMMAND:        /* They didn't see out ZRQINIT */
  966.             stohdr(0L);
  967.             zshhdr(ZRQINIT, Txhdr);
  968.             continue;
  969.         case ZRINIT:
  970.             Rxflags = 0377 & Rxhdr[ZF0];
  971.              Txfcs32 = (Wantfcs32 && (Rxflags & CANFC32));
  972.  
  973.             Rxbuflen = (0337 & Rxhdr[ZP0])+((0377 & Rxhdr[ZP1])<<8);
  974.             vfile("Rxbuflen=%d Tframlen=%d", Rxbuflen, Tframlen);
  975.             siggi = 0;
  976. #ifndef READCHECK
  977. #ifdef USG
  978.             mode(2);    /* Set cbreak, XON/XOFF, etc. */
  979. #else
  980.             /* Use 1024 byte frames if no sample/interrupt */
  981.             if (Rxbuflen < 32 || Rxbuflen > 1024) {
  982.                 Rxbuflen = 1024;
  983.                 vfile("Rxbuflen=%d", Rxbuflen);
  984.             }
  985. #endif
  986. #endif
  987.             /* Override to force shorter frame length */
  988.             if (Rxbuflen && (Rxbuflen>Tframlen) && (Tframlen>=32))
  989.                 Rxbuflen = Tframlen;
  990.             if ( !Rxbuflen && (Tframlen>=32) && (Tframlen<=1024))
  991.                 Rxbuflen = Tframlen;
  992.             vfile("Rxbuflen=%d", Rxbuflen);
  993.  
  994.             /*
  995.              * If input is not a regular file, force ACK's each 1024
  996.              *  (A smarter strategey could be used here ...)
  997.              */
  998.             if ((Rxbuflen == 0) || (Rxbuflen > 1024))
  999.                 Rxbuflen = 1024;
  1000.             vfile("Rxbuflen=%d", Rxbuflen);
  1001.  
  1002.             return (sendzsinit());
  1003.         case ZCAN:
  1004.         case TIMEOUT:
  1005.             return ERROR;
  1006.         case ZRQINIT:
  1007.             if (Rxhdr[ZF0] == ZCOMMAND)
  1008.                 continue;
  1009.         default:
  1010.             zshhdr(ZNAK, Txhdr);
  1011.             continue;
  1012.         }
  1013.     }
  1014.     return ERROR;
  1015. }
  1016.  
  1017. /* Send send-init information */
  1018. sendzsinit()
  1019. {
  1020.     register int c;
  1021.     register int errors;
  1022.  
  1023.     if (Myattn[0] == '\0')
  1024.         return OK;
  1025.  
  1026.     errors = 0;
  1027.     for (;;) {
  1028.         stohdr(0L);
  1029.         zsbhdr(ZSINIT, Txhdr);
  1030.         zsdata(Myattn, 1+strlen(Myattn), ZCRCW);
  1031.         c = zgethdr(Rxhdr, 1);
  1032.         switch (c) {
  1033.         case ZCAN:
  1034.             return ERROR;
  1035.         case ZACK:
  1036.             return OK;
  1037.         default:
  1038.             if (++errors > 9)
  1039.                 return ERROR;
  1040.             continue;
  1041.         }
  1042.     }
  1043. }
  1044.  
  1045. /* Send file name and related info */
  1046. zsendfile(buf, blen)
  1047. char *buf;
  1048. int blen;
  1049. {
  1050.     register int c;
  1051.  
  1052.     for (;;) {
  1053.         Txhdr[ZF0] = Lzconv;    /* file conversion request */
  1054.         Txhdr[ZF1] = Lzmanag;    /* file management request */
  1055.         Txhdr[ZF2] = Lztrans;    /* file transport request */
  1056.         Txhdr[ZF3] = 0;
  1057.         zsbhdr(ZFILE, Txhdr);
  1058.         zsdata(buf, blen, ZCRCW);
  1059. again:
  1060.         c = zgethdr(Rxhdr, 1);
  1061.         switch (c) {
  1062.         case ZRINIT:
  1063.             goto again;
  1064.         case ZCAN:
  1065.         case TIMEOUT:
  1066.         case ZABORT:
  1067.         case ZFIN:
  1068.             return ERROR;
  1069.         case ZSKIP:
  1070.             fprintf(stderr,"\n\n");
  1071.             stfclose(in); in = (-1); return c;
  1072.         case ZRPOS:
  1073.             if(stfseek(in, Rxpos, 0))
  1074.             {
  1075.                 fprintf(stderr,"\r\nError While Seeking file\n");
  1076.                 return ERROR;
  1077.             }
  1078.             Txpos = Rxpos; Lastc = (-1); Dontread = FALSE;
  1079.             return zsendfdata();
  1080.         case ERROR:
  1081.         default:
  1082.             continue;
  1083.         }
  1084.     }
  1085. }
  1086.  
  1087. /* Send the data in the file */
  1088. zsendfdata()
  1089. {
  1090.     register int c, c1, e;
  1091.     register int newcnt;
  1092.     register long tcount = 0;
  1093.     static int tleft = 6;    /* Counter for test mode */
  1094.     
  1095.     if (Baudrate > 300)
  1096.         Blklen = 256;
  1097.     if (Baudrate > 2400)
  1098.         Blklen = KSIZE;
  1099.     if (Rxbuflen && Blklen>Rxbuflen)
  1100.         Blklen = Rxbuflen;
  1101.     if (blkopt && Blklen > blkopt)
  1102.         Blklen = blkopt;
  1103.     vfile("Rxbuflen=%d Blklen=%d", Rxbuflen, Blklen);
  1104. somemore:
  1105.     if (setjmp(intrjmp)) {
  1106. waitack:
  1107.         switch (c1 = getinsync()) {
  1108.         default:
  1109.         case ZCAN:
  1110.             fprintf(stderr,"\r\nReceiver Cancelled Transfer\n\n");
  1111.             stfclose(in);
  1112.             in = (-1);
  1113.             return ERROR;
  1114.         case ZSKIP:
  1115.             fprintf(stderr,"\r\nReceiver forced SKIP Transfer(1)\n\n");
  1116.             stfclose(in);
  1117.             in = (-1);
  1118.             return c1;
  1119.         case ZACK:
  1120.             tcount += c;
  1121.             lreport(tcount);
  1122.             /* fall thru */
  1123.         case ZRPOS:
  1124.             break;
  1125.         case ZRINIT:
  1126.             return OK;
  1127.         }
  1128.     }
  1129.  
  1130.     siggi = 1;
  1131.     newcnt = Rxbuflen;
  1132.     stohdr(Txpos);
  1133.     zsbhdr(ZDATA, Txhdr);
  1134.  
  1135.     /*
  1136.      * Special testing mode.  This should force receiver to Attn,ZRPOS
  1137.      *  many times.  Each time the signal should be caught, causing the
  1138.      *  file to be started over from the beginning.
  1139.      */
  1140. #ifdef TESTATTN
  1141.     if (Testattn) {
  1142.         if ( --tleft)
  1143.             while (tcount < 20000) {
  1144.                 wr_modem(qbf);
  1145.                 tcount += strlen(qbf);
  1146. #ifdef READCHECK
  1147.                 while (Bconstat(1)) {
  1148.                     switch (sreadline(1)) {
  1149.                     case CAN:
  1150.                     case ZPAD:
  1151.                         goto waitack;
  1152.                     }
  1153.                 }
  1154. #endif
  1155.             }
  1156.         siggi = 0; canit();
  1157.         stsleep(3); purgeline(); mode(0);
  1158. #ifdef SDEBUG
  1159.         if(logf != (FILE *)NULL)
  1160.             fclose(logf);
  1161. #endif
  1162.  
  1163. /*        printf("\nsz: Tcount = %ld\n", tcount); */
  1164.         if (tleft) {
  1165.             /* printf("\r\nERROR: Interrupts Not Caught\n"); */
  1166.             aexit(1);
  1167.         }
  1168.         aexit(0);
  1169.     }
  1170. #endif
  1171.  
  1172.     do {
  1173.         if (Dontread) {
  1174.             c = Lastc;
  1175.         } else {
  1176.             c = zfilbuf(secbuf, Blklen);
  1177.             Lastread = Txpos;  Lastc = c;
  1178.         }
  1179. #ifdef SDEBUG
  1180.         if (Verbose > 10)
  1181.             vfile("Dontread=%d c=%d", Dontread, c);
  1182. #endif
  1183.  
  1184.         Dontread = FALSE;
  1185.         if (c < Blklen)
  1186.             e = ZCRCE;
  1187.         else if (Rxbuflen && (newcnt -= c) <= 0)
  1188.             e = ZCRCW;
  1189.         else
  1190.             e = ZCRCG;
  1191.         zsdata(secbuf, c, e);
  1192.         Txpos += c;
  1193.  
  1194.         if (e == ZCRCW)
  1195.             goto waitack;
  1196. #ifdef READCHECK
  1197.         /*
  1198.          * If the reverse channel can be tested for data,
  1199.          *  this logic may be used to detect error packets
  1200.          *  sent by the receiver, in place of setjmp/longjmp
  1201.          *  rdchk(fdes) returns non 0 if a character is available
  1202.          */
  1203.         flush_modem();
  1204.         while (Bconstat(1)) {
  1205.             switch (sreadline(1)) {
  1206.             case CAN:
  1207.             case ZPAD:
  1208.                 zsdata(secbuf, 0, ZCRCE);
  1209.                 goto waitack;
  1210.             }
  1211.         }
  1212. #endif
  1213.     } while (c == Blklen);
  1214.     tcount += c;
  1215.     lreport(tcount);
  1216.     siggi = 0;
  1217.     lsct = 1;
  1218.  
  1219.     for (;;) {
  1220.         stohdr(Txpos);
  1221.         zsbhdr(ZEOF, Txhdr);
  1222.         switch (getinsync()) {
  1223.         case ZACK:
  1224.             continue;
  1225.         case ZRPOS:
  1226.             goto somemore;
  1227.         case ZRINIT:
  1228.             return OK;
  1229.         case ZSKIP:
  1230.             fprintf(stderr,"\r\nReceiver forced SKIP Transfer(2)\n\n");
  1231.             stfclose(in);
  1232.             in = (-1);
  1233.             return c;
  1234.         default:
  1235.             fprintf(stderr,"\r\nErrors while Send Data\n\n");
  1236.             stfclose(in);
  1237.             in = (-1);
  1238.             return ERROR;
  1239.         }
  1240.     }
  1241. }
  1242.  
  1243. /*
  1244.  * Respond to receiver's complaint, get back in sync with receiver
  1245.  */
  1246. getinsync()
  1247. {
  1248.     register int c;
  1249.  
  1250.     for (;;) {
  1251. #ifdef TESTATTN
  1252.         if (Testattn) {
  1253.             wr_modem("\r\n\n\n***** Signal Caught *****\r\n");
  1254.             Rxpos = 0; c = ZRPOS;
  1255.         } else
  1256. #endif
  1257.  
  1258.             c = zgethdr(Rxhdr, 0);
  1259.         switch (c) {
  1260.         case ZCAN:
  1261.         case ZABORT:
  1262.         case ZFIN:
  1263.         case TIMEOUT:
  1264.             return ERROR;
  1265.         case ZRPOS:
  1266.             if (Lastc >= 0 && Lastread == Rxpos) {
  1267.                 Dontread = TRUE;
  1268.             } else {
  1269.                 /* clearerr(in); */    /* In case file EOF seen */
  1270.                 if(stfseek(in, Rxpos, 0))
  1271.                 {
  1272.                     fprintf(stderr,"\r\nError While Seeking file\n");
  1273.                     return ERROR;
  1274.                 }
  1275.  
  1276.             }
  1277.             Txpos = Rxpos;
  1278.             return c;
  1279.         case ZACK:
  1280.             return c;
  1281.         case ZRINIT:
  1282.         case ZSKIP:
  1283.             fprintf(stderr,"\n\n");
  1284.             stfclose(in);
  1285.             in = (-1);
  1286.             return c;
  1287.         case ERROR:
  1288.         default:
  1289.             zsbhdr(ZNAK, Txhdr);
  1290.             continue;
  1291.         }
  1292.     }
  1293. }
  1294. /* Say "bibi" to the receiver, try to do it cleanly */
  1295. saybibi()
  1296. {
  1297.     for (;;) {
  1298.         stohdr(0L);
  1299.         zsbhdr(ZFIN, Txhdr);
  1300.         switch (zgethdr(Rxhdr, 0)) {
  1301.         case ZFIN:
  1302.             sendline('O'); sendline('O'); flush_modem();
  1303.         case ZCAN:
  1304.         case TIMEOUT:
  1305.             return;
  1306.         }
  1307.     }
  1308. }
  1309.  
  1310. /* Send command and related info */
  1311. zsendcmd(buf, blen)
  1312. char *buf;
  1313. {
  1314.     register int c, errors;
  1315.     long cmdnum;
  1316.  
  1317. /*    cmdnum = getpid(); */
  1318.     cmdnum = 1;    /* A random # */
  1319.     errors = 0;
  1320.     for (;;) {
  1321.         stohdr(cmdnum);
  1322.         Txhdr[ZF0] = Cmdack1;
  1323.         zsbhdr(ZCOMMAND, Txhdr);
  1324.         zsdata(buf, blen, ZCRCW);
  1325. listen:
  1326.         Rxtimeout = 100;        /* Ten second wait for resp. */
  1327.         c = zgethdr(Rxhdr, 1);
  1328.  
  1329.         switch (c) {
  1330.         case ZRINIT:
  1331.             continue;
  1332.         case ERROR:
  1333.         case TIMEOUT:
  1334.             if (++errors > Cmdtries)
  1335.                 return ERROR;
  1336.             continue;
  1337.         case ZCAN:
  1338.         case ZABORT:
  1339.         case ZFIN:
  1340.         case ZSKIP:
  1341.         case ZRPOS:
  1342.             return ERROR;
  1343.         default:
  1344.             if (++errors > 10)
  1345.                 return ERROR;
  1346.             continue;
  1347.         case ZCOMPL:
  1348.             Exitcode = Rxpos;
  1349.             saybibi();
  1350.             return OK;
  1351.         case ZRQINIT:
  1352.             vfile("******** RZ *******");
  1353. /*            stsystem("rz"); */
  1354.             vfile("******** SZ *******");
  1355.             goto listen;
  1356.         }
  1357.     }
  1358. }
  1359.  
  1360. wr_modem(s)
  1361. register char *s;
  1362. {
  1363.     while(*s != '\0')
  1364.         Bconout(1, *s++);
  1365. }
  1366.  
  1367. /* OLD FASHIONED - but works */
  1368. flush_modem()
  1369. {
  1370.     while(Bcostat(1) == 0);
  1371. }
  1372.  
  1373. /* Super Duper, but it does'nt work */
  1374. /*
  1375. flush_modem()
  1376. {
  1377.     IOREC *piorec;
  1378.  
  1379.     while(Bcostat(1) == 0); */
  1380.  
  1381.     /* Get pointer to Rs232 output record */
  1382. /*    piorec = (IOREC *)Iorec(0) + sizeof(IOREC); */
  1383.     
  1384.     /* Wait till head and tail pointers are the same */
  1385. /*    while(piorec->ibufhd != piorec->ibuftl) */
  1386.         /* loop */ /* ;
  1387. } */
  1388.  
  1389. /*
  1390.  * If called as sb use YMODEM protocol
  1391.  */
  1392. schkinvok(s)
  1393. char *s;
  1394. {
  1395.     if (s[0]=='s' && s[1]=='b') {
  1396.         Nozmodem = TRUE; Blklen=KSIZE;
  1397.     }
  1398. }
  1399.  
  1400. /** EOF **/
  1401.